'use strict';

const BaseService = require('./base');
const modelName = 'MemberUser';
const crypto = require('crypto');

class MemberUserService extends BaseService {
  constructor(ctx) {
    super(ctx, modelName);
  }
  /**
   * 创建会员用户
   * @param {Object} data - 用户数据
   * @return {Object} 创建的用户信息
   */
  async create(data) {
    const { ctx } = this;
    // 密码加密
    data.password = this.encryptPassword(data.password);
    return await ctx.model.MemberUser.create(data);
  }

  /**
   * 根据手机号查询用户
   * @param {String} phone - 手机号
   * @return {Object} 用户信息
   */
  async findByPhone(phone) {
    const { ctx } = this;
    return await ctx.model.MemberUser.findOne({
      where: { phone },
    });
  }

  /**
   * 根据openid查询用户
   * @param {String} openid - 微信openid
   * @return {Object} 用户信息
   */
  async findByOpenid(openid) {
    const { ctx } = this;
    return await ctx.model.MemberUser.findOne({
      where: { openid },
    });
  }

  /**
   * 根据用户ID查询用户
   * @param {Number} id - 用户ID
   * @return {Object} 用户信息
   */
  async findById(id) {
    const { ctx } = this;
    return await ctx.model.MemberUser.findByPk(id);
  }

  /**
   * 更新用户信息
   * @param {Number} id - 用户ID
   * @param {Object} data - 更新的用户数据
   * @return {Object} 更新后的用户信息
   */
  async update(id, data) {
    const { ctx } = this;
    const user = await ctx.model.MemberUser.findByPk(id);
    if (!user) {
      return null;
    }
    // 如果更新密码，需要加密
    if (data.password) {
      data.password = this.encryptPassword(data.password);
    }
    return await user.update(data);
  }

  /**
   * 更新用户登录时间
   * @param {Number} id - 用户ID
   * @return {Object} 更新的结果
   */
  async updateLoginTime(id) {
    const { ctx } = this;
    return await ctx.model.MemberUser.update(
      { last_login_time: new Date() },
      { where: { id } }
    );
  }

  /**
   * 用户登录
   * @param {String} phone - 手机号
   * @param {String} password - 密码
   * @return {Object} 登录结果
   */
  async login(phone, password) {
    const { ctx } = this;
    const user = await this.findByPhone(phone);
    
    if (!user) {
      return { success: false, message: '用户不存在' };
    }
    
    if (user.status !== 1) {
      return { success: false, message: '用户已被禁用' };
    }
    
    const encryptedPassword = this.encryptPassword(password);
    if (user.password !== encryptedPassword) {
      return { success: false, message: '密码错误' };
    }
    
    // 更新登录时间
    await this.updateLoginTime(user.id);
    
    // 剔除敏感信息
    const userInfo = this.excludeSensitiveInfo(user.dataValues);
    
    return { success: true, data: userInfo };
  }

  /**
   * 微信登录
   * @param {String} openid - 微信openid
   * @param {Object} userInfo - 微信用户信息
   * @return {Object} 登录结果
   */
  async wechatLogin(openid, userInfo = {}) {
    const { ctx } = this;
    let user = await this.findByOpenid(openid);
    
    if (!user) {
      // 创建用户
      const userData = {
        openid,
        nickname: userInfo.nickName || '',
        avatar: userInfo.avatarUrl || '',
        gender: userInfo.gender || 0,
        password: this.encryptPassword(this.generateRandomPassword()), // 生成随机密码
      };
      
      user = await this.create(userData);
    } else if (user.status !== 1) {
      return { success: false, message: '用户已被禁用' };
    }
    
    // 更新登录时间
    await this.updateLoginTime(user.id);
    
    // 剔除敏感信息
    const safeUserInfo = this.excludeSensitiveInfo(user.dataValues);
    
    return { success: true, data: safeUserInfo };
  }

  /**
   * 密码加密
   * @param {String} password - 原始密码
   * @return {String} 加密后的密码
   */
  encryptPassword(password) {
    return crypto
      .createHash('md5')
      .update(password + 'urban-service-management')
      .digest('hex');
  }

  /**
   * 生成随机密码
   * @return {String} 随机密码
   */
  generateRandomPassword() {
    return Math.random().toString(36).substring(2, 10);
  }

  /**
   * 剔除敏感信息
   * @param {Object} user - 用户信息
   * @return {Object} 剔除敏感信息后的用户信息
   */
  excludeSensitiveInfo(user) {
    const { password, ...rest } = user;
    return rest;
  }
}

module.exports = MemberUserService;
